﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
//class A
//{
//private:
//	static int _k;//静态成员变量没有存储在对象里面，存储在静态区里面的
//	//所以我们在计算大小的时候我们是不会计算这个静态成员变量的
//	int _h = 1;
//public:
//	class B // B默认就是A的友元
//	{
//
//	public:
//		void foo(const A& a)
//		{
//			cout << _k << endl; //OK
//			cout << a._h << endl; //OK
//		}
//	private:
//		int _b;
//	};
//};
//int main()
//{
//	cout << sizeof(A) << endl;//A的大小是4字节，只计算了A这个类中的_h变量
//	//并且没有计算B这个类的大小 
//	A::B b;
//	return 0;
//}


//class A
//{
//	
//public :
//	A(int a = 0)
//		: _a(a)
//	{
//		cout << "A(int a)" << endl;
//	} 
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//private:
//	int _a;
//};
//class Solution {
//public:
//	int Sum_Solution(int n) {
//		//...
//		return n;
//	}
//};
//void func(A aa=A(1))
//{}
//
//
//int main()
//{
//
//	func();
//
//	//有名对象
//	A aa1(1);
//	A aa2;
//
//	//匿名对象
//	
//
//	//这种事有名对象调用函数的操作
//	Solution s1;
//	cout << s1.Sum_Solution(10) << endl;
//
//	//下面是匿名对象调用函数
//	cout << Solution().Sum_Solution(10) << endl;
//
//	const A& r = A();
//	return 0;
//}
////对于有名对象的话，他们的析构函数是在main函数结束以后进行的
////但是这个匿名对象，生命周期在当前这一行，这一行运行结束之后就进行析构函数，就是下一行进行析构
//
////而且匿名对象参数无参的时候我们也是需要将这个括号带着的

//#include<iostream>
//using namespace std;
//class A
//{
//	
//public :
//	A(int a = 0)
//		: _a1(a)
//	{
//		cout << "A(int a)" << endl;
//	} 
//	A(const A& aa)
//		:_a1(aa._a1)
//	{
//		cout << "A(const A& aa)" << endl;
//	}
//	A& operator=(const A& aa)
//	{
//		cout << "A& operator=(const A& aa)" << endl;
//		if (this != &aa)
//		{
//			_a1 = aa._a1;
//		} 
//		return* this;
//	} 
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//private: 
//	int _a1 = 1;
//};
//void f1(A aa)
//{}
//int main()
//{
//	//优化
//	A aa1=1;
//
//	// 传值传参
//	A aa1;
//	f1(aa1);
//	cout << endl;
//
//	// 隐式类型，连续构造+拷⻉构造->优化为直接构造
//	f1(1);				
//
//	// ⼀个表达式中，连续构造+拷⻉构造->优化为⼀个构造
//	f1(A(2));
//	cout << endl; 
//	return 0;
//}


//A f2()
//{
//	A aa;
//	return aa;//传值返回
//}
//int main()
//{
//	// 返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 （vs2019 debug）
//// ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，直接变为构造。（vs2022 debug
//	f2();
//	cout << endl;
//
//	// 返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 （vs2019 debug）
//// ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，直接变为构造。（vs2022 debug）
//	A aa2 = f2();
//	cout << endl;
//	return 0;
//}


int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
	static int staticVar = 1;
	int localVar = 1;
	int num1[10] = { 1, 2, 3, 4 };
	char char2[] = "abcd";
	const char* pChar3 = "abcd";
	int* ptr1 = (int*)malloc(sizeof(int) * 4);
	int* ptr2 = (int*)calloc(4, sizeof(int));
	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
	free(ptr1);
	free(ptr3);
}

/*

. 选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？__c__
staticGlobalVar在哪里？__c__
staticVar在哪里？__c__
localVar在哪里？__a__
num1 在哪里？___a_
char2在哪里？___a_
*char2在哪里？_a__
pChar3在哪里？__a__
*pChar3在哪里？__*pChar3指向的是abcd，abcd在常量区   D__
ptr1在哪里？__a__
*ptr1在哪里？__b__//malloc在堆上

*/
/*
全局数据和静态数据都在静态区
局部静态变量也是存在于静态区的

*/

//void Test()
//{
//	// 动态申请一个int类型的空间
//	int* ptr4 = new int;
//	// 动态申请一个int类型的空间并初始化为10
//	int* ptr5 = new int(10);
//	// 动态申请10个int类型的空间
//	int* ptr6 = new int[3];
//
//	//如果是多个数组中的对象要初始化的话
//	int* ptr7 = new int[3] {1, 2, 3};
//
//	delete ptr4;
//	delete ptr5;
//	delete[] ptr6;
//}


//class A
//{
//public:
//	A(int a = 0)
//		: _a(a)
//	{
//		cout << "A():" << this << endl;
//	}
//	~A()
//	{
//		cout << "~A():" << this << endl;
//	}
//private:
//	int _a;
//};
//
//struct ListNode//链表
//{
//	int _val;
//	ListNode* _next;
//	ListNode(int val)
//		:_val(val)
//		, _next(nullptr)
//	{
//
//	}
//};
//int main()
//{
//	//只申请空间
//	A* p1 = (A*)malloc(sizeof(A));
//
//	//用new就方便很多了
//	//申请空间+构造函数
//	A* p2 = new A(1);
//
//	//只释放空间
//	free(p1);
//
//	//释放空间+析构函数
//	delete p2;
//
//	A* p6 = new A[10];//申请10个对象的空间
//	//回调用10次构造函数
//	delete[] p6;
//
//	A aa1(1);
//	A aa2(1);
//
//	//A* p7 = new A[10]{ aa1,aa2 };
//	A* p7 = new A[10]  {1,2,3};//直接使用隐式类型转换
//	delete[] p7;
//	 
//	//在C语言的链表中我们通常需要写个buynode来申请一个节点
//	//但是我们在C++中就不用了，我们直接new就行了
//	ListNode* n1 = new ListNode(1);//申请空间并且调用ListNode的构造函数
//	ListNode* n2 = new ListNode(2);
//	ListNode* n3 = new ListNode(3);
//	ListNode* n4 = new ListNode(4);
//
//	n1->_next = n2;
//	n2->_next = n3;
//	n3->_next = n4;
//
//
//	return 0;
//}
////在一个类中一定要提供默认构造，不然就会出现很多的问题了

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

struct ListNode//链表
{
	int _val;
	ListNode* _next;
	ListNode(int val)
		:_val(val)
		, _next(nullptr)
	{

	}
};
int main()
{
	A* p2 = new A(1);

 
	//释放空间+析构函数
	delete p2;




	return 0;
}